import java.util.Arrays;
import java.util.Scanner;

class Orange{
    int a;//酸
    int b;//甜
    Orange(){}

    Orange(int a,int b){
        this.a = a;
        this.b = b;
    }
}


public class Test {


    //01背包(动态规划
    //已知一个背包最多能容纳体积之和为v的物品
    //现有 n 个物品，第 i 个物品的体积为 vi , 重量为 wi
    //求当前背包最多能装多大重量的物品?
    //数据范围：1≤v≤1000 ，1≤n≤1000 ，1≤vi≤1000, 1≤wi≤1000
    //进阶 ：O(n⋅v)
    //示例1
    //输入：
    //10,2,[[1,3],[10,4]]
    //返回值：
    //4
    //说明：
    //第一个物品的体积为1，重量为3，第二个物品的体积为10，重量为4。只取第二个物品可以达到最优方案，取物重量为4
    //示例2
    //输入：
    //10,2,[[1,3],[9,8]]
    //返回值：
    //11
    //说明：
    //两个物品体积之和等于背包能装的体积，所以两个物品都取是最优方案

    //算法思路：
    //01 背包模板题：
    //1. 状态表⽰：
    //dp[i][j] 表⽰从前 i 个物品中挑选，总体积不超过 j 的情况下，
    // 最⼤重量是多少。
    //2. 状态转移⽅程：
    //根据「最后⼀步」的状况，来分情况讨论：
    //i. 不选第 i 个物品：相当于就是去前 i - 1 个物品中挑选，
    // 并且总体积不超过 j 。此时 dp[i][j] = dp[i - 1][j] ；
    //ii. 选择第 i 个物品：那么我就只能去前 i - 1 个物品中，
    // 挑选总体积不超过 j - v[i]
    //的物品。此时 dp[i][j] = dp[i - 1][j - v[i]] + w[i] 。
    // 但是这种状态不⼀定存在，因此需要特判⼀下。
    //综上，状态转移⽅程为： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] +w[i]) 。
    int[] dp = new int[1010];
    public int knapsack (int V, int n, int[][] vw) {
        for (int i = 0; i < n; i++) {
            for (int j = V; j >= vw[i][0]; j--) {
                dp[j] = Math.max(dp[j],dp[j-vw[i][0]]+vw[i][1]);
            }
        }
        return dp[V];
    }



    //chika和蜜柑(排序/topK
    //链接：https://ac.nowcoder.com/acm/problem/26221
    //来源：牛客网
    //
    //chika很喜欢吃蜜柑。每个蜜柑有一定的酸度和甜度，chika喜欢吃甜的，
    // 但不喜欢吃酸的。
    //一共有n个蜜柑，chika吃k个蜜柑，将获得所吃的甜度之和与酸度之和。
    // chika想获得尽可能大的甜度总和。如果有多种方案，她希望总酸度尽可能小。
    //她想知道，最终的总酸度和总甜度是多少？
    //输入描述:
    //第一行有两个正整数n和k，分别代表蜜柑总数和chika吃的蜜柑数量。(1≤k≤n≤200000)
    //第二行有n个正整数ai，分别代表每个蜜柑的酸度。（1≤ai≤1e9）
    //第二行有n个正整数bi，分别代表每个蜜柑的甜度。（1≤bi≤1e9）
    //输出描述:
    //两个正整数，用空格隔开。分别表示总酸度和总甜度。
    //示例1
    //输入
    //3 2
    //1 3 4
    //2 2 5
    //输出
    //5 7
    //说明
    //选择1号和3号蜜柑，总酸度为5，总甜度为7，为最优解。
    //算法思路：
    //排序：
    //将每个橘⼦按照甜度由⾼到低排序，相同甜度的橘⼦按照酸度由低到⾼排序。
    //然后提取排序后的前 k 个橘⼦就好了。
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int n= in.nextInt(),k = in.nextInt();
        Orange[] o = new Orange[n];
        for (int i = 0; i < n; i++) {
            o[i] = new Orange();
            o[i].a = in.nextInt();
        }
        for (int i = 0; i < n; i++) {
            o[i].b = in.nextInt();
        }

        Arrays.sort(o,(x,y)->{
            if (x.b == y.b){
                return x.a - y.a;
            }
            return y.b - x.b;
        });

        long x = 0,y = 0;
        for (int i = 0; i < k; i++) {
            x+=o[i].a;
            y+=o[i].b;
        }
        System.out.println(x+" "+y);
    }



    //压缩字符串（一）
    //双指针模拟
    //利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。
    // 比如，字符串aabcccccaaa会变为a2bc5a3。
    //1.如果只有一个字符，1不用写
    //2.字符串中只包含大小写英文字母（a至z）。
    //数据范围:
    //0<=字符串长度<=50000
    //要求：时间复杂度O(N）
    //示例1
    //输入：
    //"aabcccccaaa"
    //返回值：
    //"a2bc5a3"

    //示例2
    //输入：
    //"shopeew"
    //返回值：
    //"shope2w"
    public String compressString (String param) {
        StringBuffer ret = new StringBuffer();
        char[] ch = param.toCharArray();
        int l = 0,r = 0,n = ch.length;
        while(l < n){
            while (r+1<n && ch[r+1] == ch[r]){
                r++;
            }
            int len = r - l  + 1;
            ret.append(ch[l]);
            if(len>1){
                ret.append(len);
            }
            l = r +1;
            r = l;
        }
        return ret.toString();
    }
}
